Java三种方法实现字符串排序

最新推荐文章于 2024-10-10 22:44:45 发布

白鳯

最新推荐文章于 2024-10-10 22:44:45 发布

阅读量3.4w

点赞数 13

分类专栏：简单算法文章标签： java 字符串排序算法

本文链接：https://blog.csdn.net/weixin_44368437/article/details/113446207

版权

简单算法专栏收录该内容

14 篇文章 12 订阅

订阅专栏

Java字符串排序

文章目录

- Java字符串排序

排序方法概述

对于许多应用，决定顺序的键都是字符串。本篇讲述如何利用字符串的特殊性质来对其进行高效的排序。

第一类方法会从右到左检查键中的字符。这种方法一般被称为低位优先（Least-Significant-DigitFirst，LSD）的字符串排序。如果将一个字符串看做一个256进制的数字，那么从右向左检查字符串就等价于先检查数字的最低位。这种方法最适合用于键的长度都相同的字符串排序应用。

第二类方法会从左到右检查键中的字符，首先查看的是最高位的字符。这种方法通常称为高位优先（MSD）的字符串排序。高位优先的字符串排序和快速排序类似，因为它们都会将需要排序的数组切分为独立的部分并递归地用相同的方法处理子数组来完成排序。它们的区别之处在于高位优先的字符串排序算法在切分时仅使用键的第一个字符，而快速排序的比较则会涉及键的全部。

第三种方法是高位优先的字符串排序算法的改进快速排序，根据键的首字母进行三向切分，仅在中间子数组中的下一个字符（因为键的首字母都与切分字符相等）继续递归排序。

键索引计数法

作为热身，我们先学习一种适用于小整数键的简单排序方法。这种叫做键索引计数的方法本身就很实用，同时也是要学习的三种排序算法中前两种的基础。它其实就桶计数。

现在来情景引入，老师在统计学生的分数时可能会遇到以下数据处理问题。学生被分为若干组，标号为1、2、3、4等。在某些情况下，我们希望将全班同学按组分类。因为组的编号是较小的整数，使用键索引计数法来排序时很合适的。假设数组a[]中的每个元素都保存了一个名字和一个组号，其中组号在0到R-1之间，代码a[i].key()会返回指定学生的组号。四个步骤见代码

int N = a.length;
int R = 256;    //R为字符基数

String[] aux = new String[N];
int[] count = new int[R + 1];

//计算出现频率
for (int i = 0; i < N; i++) 
    count[a[i].key() + 1]++;

//将频率转换为索引
for (int r = 0; r < R; r++) 
    count[r + 1] += count[r];

//将元素分类
for (int i = 0; i < N; i++) 
    aux[count[a[i].key()]++] = a[i];

//回写
for (int i = 0; i < N; i++)
    a[i] = aux[i];

命题A：键索引计数法排序N个键为0到R-1之间的整数的元素需要访问数组11N+4R+1次

低位优先的字符串排序（LSD）

如果字符串的长度均为W，那就从右向左以每个位置的字符作为键，用键索引计数法将字符串排序W遍。

命题B：低位优先的字符串排序算法能够稳定地将定长字符串排序

class LSD{
	// Least-Significant-Digit First
	//低位优先的字符串排序(基数排序)
	public static void sort(String[] a, int W) {
		//通过前W个字符将a[]排序
		int N = a.length;
		int R = 256;    //基数
		String[] aux = new String[N];  //辅助数组\

		for(int d = W - 1; d >= 0; d--) {
			//根据第d个字符用键索引计数法排序
			int[] count = new int[R + 1];   
			//计算出现频率
			for (int i = 0; i < N; i++)
				count[a[i].charAt(d) + 1]++;
			//将频率转换为索引
			for (int r = 0; r < R; r++)
				count[r + 1] += count[r];
			//将元素分类
			for (int i = 0; i < N; i++) 
				aux[count[a[i].charAt(d)]++] = a[i];
			//回写
			for (int i = 0; i < N; i++) 
				a[i] = aux[i];
		}
	}
}

在许多字符串排序的应用中，键的长度可能互不相同。改进后的低位优先的字符串排序是可以适应这些情况的。下来讲解两种处理变长键排序的算法

高位优先的字符串排序（MSD）

首先用键索引计数法将所有字符串按照首字母排序，然后（递归地）再将每个首字母所对应的子数组排序（忽略首字母，因为每一类中的所有首字母都是相同的）。和快速排序一样，高位优先的字符串排序会将数组切分为能够独立排序的子数组来完成排序任务，但它的切分会为每个首字母得到一个子数组，而不是像快速排序中那样产生固定的两个或者三个切分。

在高位优先的字符串排序算法中，要特别注意到达字符串末尾的情况。在排序中，合理的做法是将所有字符都已被检查过的字符串所在的子数组排在所有子数组的前面，这样就不需要递归地将该子数组排序。为了简化这两步计算，我们使用了一个接受两个参数的私有方法charAt()来将字符串中字符索引转化为数组索引，当指定的位置超过了字符串末尾时该方法返回-1,。然后将所有返回值加1，得到一个非负的int值并用它作为count[]的索引。这种转换意味着字符串中的每个字符都可能产生R+1种不同的值：0表示字符串的结尾，1表示字符串的第一个字符，2表示字符串的第二个字符，等等。因为建索引计数法本来就需要一个额外的位置，所以使用代码int count[] = new int[R + 2]

class MSD{
	//高位优先的字符串排序
	private static int R = 256;      //基数
	private static final int M = 15; //小数组的切换阈值
	private static String[] aux;     //数组分类的辅助数组
	private static int charAt(String s, int d) {
		if(d < s.length()) {
			return s.charAt(d);
		}else {
			return -1;
		}
	}
	public static void sort(String[] a) {
		int N = a.length;
		aux = new String[N];
		sort(a, 0, N - 1, 0);
	}
	private static void sortInsert(String[] a, int lo, int hi) {
		//小型数组进行插入排序
		for (int i = lo + 1; i <= hi; i++) {
			for(int j = i; j > lo && a[j].compareTo(a[j - 1]) < 0; j--) {
				String tmp = a[j];
				a[j] = a[j - 1];
				a[j - 1] = tmp;
			}
		}
	}
	private static void sort(String[] a, int lo, int hi, int d) {
		//以第d个字符为键将a[lo]至a[hi]排序
		if(hi <= lo + M) {
			sortInsert(a, lo, hi);
			return; 
		}
		int [] count = new int[R + 2];    //计算频率
		for(int i = lo; i <= hi; i++) {
			count[charAt(a[i], d) + 2]++;
		}
		for(int r = 0; r < R + 1; r++) {  //将频率转换为索引
			count[r + 1] += count[r];
		}
		for(int i = lo; i <= hi; i++) {   //数据分类
			aux[count[charAt(a[i], d) + 1]++] = a[i];
		}
		for(int i = lo; i <= hi; i++) {   //回写
			a[i] = aux[i - lo]; 
		}
		//递归的以每个字符为键进行排序
		for(int r = 0; r <R; r++) {
			sort(a, lo + count[r], lo + count[r + 1] - 1, d + 1);
		}
	}
}

三向字符串快速排序

我们也可以根据高位优先的字符串排序算法改进快速排序，根据键的首字母进行三向切分，仅在中间子数组的下一个字符（因为键得出首字母都与切分字母相同）继续递归排序。这个算法的实现并不困难，参考往期排序算法中的三向切分快排即可。

尽管排序的方式有所不同，但三向字符串快速排序根据的仍然是键的首字母并使用递归的方法将其余部分排序。对于字符串的排序，这个方法比普通的快速排序和高位优先的字符串排序更友好。实际上，它就是两种算法的结合。

三向字符串快速排序只将数组切分为三部分，因此当相应的高位优先的字符串排序产生的非空切分较多时，它需要移动的数据量就会变大，因此它需要进行一系列的三向切分才能够取得多向切分的效果。但是，高位优先的字符串排序可能会创建大量（空）子数组，而三向字符串快速排序的切分总是只有三个。因此三向字符串快速排序能够很好地处理等值键、有较长公共前缀的键、取值范围较小的键和小数组-----所有高位优先的字符串排序算法不擅长的各种情况。

class Quick3string{
	//三向字符串快速排序
	private static int charAt(String s, int d) {
		if(d < s.length()) {
			return s.charAt(d);
		}
		return -1;
	}
    
	public static void sort(String[] a) {
		sort(a, 0, a.length - 1, 0);
	}
    
	private static void sort(String[] a, int lo, int hi, int d) {
		if(hi <= lo) {
			return;
		}
		int lt = lo, gt = hi, i = lo + 1;
		int v = charAt(a[lo], d);
		while(i <= gt) {
			int t = charAt(a[i], d);
			if(t < v) {
				exch(a, lt++, i++);
			}else if(t > v) {
				exch(a, i, gt--);
			}else {
				i++;
			}
		}
		//a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi]
		sort(a, lo, lt - 1, d);
		if(v >= 0) {
			sort(a, lt, gt, d + 1);
		}
		sort(a, gt + 1, hi, d);
	}
    
	private static void exch(String[] a, int i, int j) {
		String t = new String(a[i]);
		a[i] = a[j];
		a[j] = t;
	}
}